package linklist;

/**
 * @author "随风Coding"          // 系统用户名（自动填充）
 * @email 1431471764@qq.com  // 替换为你的邮箱（固定或自定义变量）
 * @date 2025/8/12 08:40    // 创建日期和时间（自动填充）
 */
public class RemoveTarget {

    /**
     * 时间复杂度 O(n)
     * 空间复杂度 O(1)
     *
     * @param head
     * @param val
     * @return
     */
    public ListNode removeElements(ListNode head, int val) {
        // 设置一个虚拟的头结点
        ListNode dummyHead = new ListNode();
        dummyHead.next = head;
        ListNode cur = new ListNode();
        cur = dummyHead;
        while (cur.next != null) {
            if (cur.next.val == val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return dummyHead.next;
    }

    /**
     * 辅助方法：打印链表内容（用于测试验证）
     *
     * @param head 链表头节点
     */
    public static void printList(ListNode head) {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val);
            if (cur.next != null) {
                System.out.print(" -> ");
            } else {
                System.out.println();
            }
            cur = cur.next;
        }
    }

    /**
     * 测试入口（主方法）
     */
    public static void main(String[] args) {
        // 测试用例 1：空链表
        ListNode head1 = null;
        RemoveTarget remover = new RemoveTarget();
        ListNode result1 = remover.removeElements(head1, 1);
        System.out.println("测试用例1（空链表）结果：");
        printList(result1); // 预期输出：（空）


        // 测试用例 2：链表只有一个节点且值为目标值
        ListNode head2 = new ListNode(2);
        ListNode result2 = remover.removeElements(head2, 2);
        System.out.println("测试用例2（单节点且值为目标值）结果：");
        printList(result2); // 预期输出：（空）


        // 测试用例 3：链表只有一个节点且值不为目标值
        ListNode head3 = new ListNode(3);
        ListNode result3 = remover.removeElements(head3, 2);
        System.out.println("测试用例3（单节点且值不为目标值）结果：");
        printList(result3); // 预期输出：3


        // 测试用例 4：链表有多个节点，包含多个目标值
        // 构造链表：1 -> 2 -> 3 -> 2 -> 4 -> null
        ListNode head4 = new ListNode(1);
        head4.next = new ListNode(2);
        head4.next.next = new ListNode(3);
        head4.next.next.next = new ListNode(2);
        head4.next.next.next.next = new ListNode(4);
        System.out.println("测试用例4（原链表）：");
        printList(head4); // 输出：1 -> 2 -> 3 -> 2 -> 4
        ListNode result4 = remover.removeElements(head4, 2);
        System.out.println("测试用例4（删除值为2的节点后）结果：");
        printList(result4); // 预期输出：1 -> 3 -> 4


        // 测试用例 5：链表所有节点值都是目标值
        // 构造链表：5 -> 5 -> 5 -> null
        ListNode head5 = new ListNode(5);
        head5.next = new ListNode(5);
        head5.next.next = new ListNode(5);
        System.out.println("测试用例5（原链表）：");
        printList(head5); // 输出：5 -> 5 -> 5
        ListNode result5 = remover.removeElements(head5, 5);
        System.out.println("测试用例5（删除所有值为5的节点后）结果：");
        printList(result5); // 预期输出：（空）


        // 测试用例 6：目标值不存在于链表中
        // 构造链表：10 -> 20 -> 30 -> null
        ListNode head6 = new ListNode(10);
        head6.next = new ListNode(20);
        head6.next.next = new ListNode(30);
        System.out.println("测试用例6（原链表）：");
        printList(head6); // 输出：10 -> 20 -> 30
        ListNode result6 = remover.removeElements(head6, 5);
        System.out.println("测试用例6（删除不存在的值后）结果：");
        printList(result6); // 预期输出：10 -> 20 -> 30
    }

}
